firstpass.h

/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */
 
#ifndef AOM_AV1_ENCODER_FIRSTPASS_H_
#define AOM_AV1_ENCODER_FIRSTPASS_H_
 
#include <stdbool.h>
 
#include "av1/common/av1_common_int.h"
#include "av1/common/enums.h"
#include "av1/encoder/lookahead.h"
#include "av1/encoder/ratectrl.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DOUBLE_DIVIDE_CHECK(x) ((x) < 0 ? (x) - 0.000001 : (x) + 0.000001)
 
#define MIN_ZERO_MOTION 0.95
#define MAX_SR_CODED_ERROR 40
#define MAX_RAW_ERR_VAR 2000
#define MIN_MV_IN_OUT 0.4
 
#define VLOW_MOTION_THRESHOLD 950
struct ThreadData;

typedef struct FIRSTPASS_STATS {
  double frame;
  double weight;
  double intra_error;
  double frame_avg_wavelet_energy;
  double coded_error;
  double sr_coded_error;
  double lt_coded_error;
  double pcnt_inter;
  double pcnt_motion;
  double pcnt_second_ref;
  double pcnt_neutral;
  double intra_skip_pct;
  double inactive_zone_rows;
  double inactive_zone_cols;
  double MVr;
  double mvr_abs;
  double MVc;
  double mvc_abs;
  double MVrv;
  double MVcv;
  double mv_in_out_count;
  double new_mv_count;
  double duration;
  double count;
  double raw_error_stdev;
  int64_t is_flash;
  double noise_var;
  double cor_coeff;
  double log_intra_error;
  double log_coded_error;
} FIRSTPASS_STATS;
 
// We want to keep one past stats for key frame detection
// in test_candidate_kf()
#define FIRSTPASS_INFO_STATS_PAST_MIN 1
 
// The size of static buffer used in FIRSTPASS_INFO.
#define FIRSTPASS_INFO_STATIC_BUF_SIZE \
  (MAX_LAP_BUFFERS + FIRSTPASS_INFO_STATS_PAST_MIN)

typedef struct {
  FIRSTPASS_STATS static_stats_buf[FIRSTPASS_INFO_STATIC_BUF_SIZE];
  FIRSTPASS_STATS *stats_buf;
  int stats_buf_size;
  int start_index;

  int stats_count;

  int cur_index;

  int future_stats_count;

  int past_stats_count;

  FIRSTPASS_STATS total_stats;
} FIRSTPASS_INFO;

aom_codec_err_t av1_firstpass_info_init(FIRSTPASS_INFO *firstpass_info,
                                        FIRSTPASS_STATS *ext_stats_buf,
                                        int ext_stats_buf_size);

aom_codec_err_t av1_firstpass_info_move_cur_index(
    FIRSTPASS_INFO *firstpass_info);

aom_codec_err_t av1_firstpass_info_pop(FIRSTPASS_INFO *firstpass_info);

aom_codec_err_t av1_firstpass_info_move_cur_index_and_pop(
    FIRSTPASS_INFO *firstpass_info);

aom_codec_err_t av1_firstpass_info_push(FIRSTPASS_INFO *firstpass_info,
                                        const FIRSTPASS_STATS *input_stats);

const FIRSTPASS_STATS *av1_firstpass_info_peek(
    const FIRSTPASS_INFO *firstpass_info, int offset_from_cur);

int av1_firstpass_info_future_count(const FIRSTPASS_INFO *firstpass_info,
                                    int offset_from_cur);

#define FC_ANIMATION_THRESH 0.15
enum {
  FC_NORMAL = 0,
  FC_GRAPHICS_ANIMATION = 1,
  FRAME_CONTENT_TYPES = 2
} UENUM1BYTE(FRAME_CONTENT_TYPE);

typedef struct GF_GROUP {
  // Frame update type, e.g. ARF/GF/LF/Overlay
  FRAME_UPDATE_TYPE update_type[MAX_STATIC_GF_GROUP_LENGTH];
  unsigned char arf_src_offset[MAX_STATIC_GF_GROUP_LENGTH];
  // The number of frames displayed so far within the GOP at a given coding
  // frame.
  unsigned char cur_frame_idx[MAX_STATIC_GF_GROUP_LENGTH];
  int layer_depth[MAX_STATIC_GF_GROUP_LENGTH];
  int arf_boost[MAX_STATIC_GF_GROUP_LENGTH];
  int max_layer_depth;
  int max_layer_depth_allowed;
  // This is currently only populated for AOM_Q mode
  int q_val[MAX_STATIC_GF_GROUP_LENGTH];
  int rdmult_val[MAX_STATIC_GF_GROUP_LENGTH];
  int bit_allocation[MAX_STATIC_GF_GROUP_LENGTH];
  // The frame coding type - inter/intra frame
  FRAME_TYPE frame_type[MAX_STATIC_GF_GROUP_LENGTH];
  // The reference frame buffer control - update or reset
  REFBUF_STATE refbuf_state[MAX_STATIC_GF_GROUP_LENGTH];
  int arf_index;  // the index in the gf group of ARF, if no arf, then -1
  int size;       // The total length of a GOP
 
  // The offset into lookahead_ctx for choosing
  // source of frame parallel encodes.
  int src_offset[MAX_STATIC_GF_GROUP_LENGTH];
  // Stores the display order hint of each frame in the current GF_GROUP.
  int display_idx[MAX_STATIC_GF_GROUP_LENGTH];
 
  // The reference frame list maps the reference frame indexes to its
  // buffer index in the decoded buffer. A value of -1 means the
  // corresponding reference frame index doesn't point towards any
  // previously decoded frame.
  int8_t ref_frame_list[MAX_STATIC_GF_GROUP_LENGTH][REF_FRAMES];
  // Update frame index
  int update_ref_idx[MAX_STATIC_GF_GROUP_LENGTH];
  // The map_idx of primary reference
  int primary_ref_idx[MAX_STATIC_GF_GROUP_LENGTH];
 
  // Indicates the level of parallelism in frame parallel encodes.
  // 0 : frame is independently encoded (not part of parallel encodes).
  // 1 : frame is the first in encode order in a given parallel encode set.
  // 2 : frame occurs later in encode order in a given parallel encode set.
  int frame_parallel_level[MAX_STATIC_GF_GROUP_LENGTH];
  // Indicates whether a frame should act as non-reference frame.
  bool is_frame_non_ref[MAX_STATIC_GF_GROUP_LENGTH];
  // Indicates whether a frame is dropped.
  bool is_frame_dropped[MAX_STATIC_GF_GROUP_LENGTH];
 
  // Stores the display order hint of the frames not to be
  // refreshed by the current frame.
  int skip_frame_refresh[MAX_STATIC_GF_GROUP_LENGTH][REF_FRAMES];
  // Stores the display order hint of the frame to be excluded during reference
  // assignment.
  int skip_frame_as_ref[MAX_STATIC_GF_GROUP_LENGTH];
  // Indicates whether a switch frame is due.
  bool is_sframe_due;
  // Indicates whether the ref frame map is overridden by the external rate
  // control.
  int use_ext_ref_frame_map[MAX_STATIC_GF_GROUP_LENGTH];
} GF_GROUP;

 
typedef struct {
  // Track if the last frame in a GOP has higher quality.
  int arf_gf_boost_lst;
} GF_STATE;
 
typedef struct {
  FIRSTPASS_STATS *stats_in_start;
  FIRSTPASS_STATS *stats_in_end;
  FIRSTPASS_STATS *stats_in_buf_end;
  FIRSTPASS_STATS *total_stats;
  FIRSTPASS_STATS *total_left_stats;
} STATS_BUFFER_CTX;


typedef struct {
  unsigned int section_intra_rating;
  // Circular queue of first pass stats stored for most recent frames.
  // cpi->output_pkt_list[i].data.twopass_stats.buf points to actual data stored
  // here.
  FIRSTPASS_STATS *frame_stats_arr[MAX_LAP_BUFFERS + 1];
  int frame_stats_next_idx;  // Index to next unused element in frame_stats_arr.
  STATS_BUFFER_CTX *stats_buf_ctx;
  FIRSTPASS_INFO firstpass_info;  // This is the first pass data structure
                                  // intended to replace stats_in
  int first_pass_done;
  int64_t bits_left;
  double modified_error_min;
  double modified_error_max;
  double modified_error_left;
 
  // Projected total bits available for a key frame group of frames
  int64_t kf_group_bits;
 
  // Error score of frames still to be coded in kf group
  double kf_group_error_left;
 
  // Over time correction for bits per macro block estimation
  double bpm_factor;
 
  // Record of target and actual bits spent in current ARF group
  int rolling_arf_group_target_bits;
  int rolling_arf_group_actual_bits;
 
  int sr_update_lag;
 
  int kf_zeromotion_pct;
  int last_kfgroup_zeromotion_pct;
  int extend_minq;
  int extend_maxq;
} TWO_PASS;

typedef struct {
  const FIRSTPASS_STATS *stats_in;
  // Pointer to the stats of the current frame.
  const FIRSTPASS_STATS *this_frame;
  double mb_av_energy;
  // An indication of the content type of the current frame
  FRAME_CONTENT_TYPE fr_content_type;
  double frame_avg_haar_energy;
} TWO_PASS_FRAME;

 
// This structure contains several key parameters to be accumulated for this
// frame.
typedef struct {
  // Intra prediction error.
  int64_t intra_error;
  // Average wavelet energy computed using Discrete Wavelet Transform (DWT).
  int64_t frame_avg_wavelet_energy;
  // Best of intra pred error and inter pred error using last frame as ref.
  int64_t coded_error;
  // Best of intra pred error and inter pred error using golden frame as ref.
  int64_t sr_coded_error;
  // Best of coded error using long term reference.
  int64_t lt_coded_error;
 
  // Count of motion vector.
  int mv_count;
  // Count of blocks that pick inter prediction (inter pred error is smaller
  // than intra pred error).
  int inter_count;
  // Count of blocks that pick second ref (golden frame).
  int second_ref_count;
  // Count of blocks where the inter and intra are very close and very low.
  double neutral_count;
  // Count of blocks where intra error is very small.
  int intra_skip_count;
  // Start row.
  int image_data_start_row;
  // Count of unique non-zero motion vectors.
  int new_mv_count;
  // Sum of inward motion vectors.
  int sum_in_vectors;
  // Sum of motion vector row.
  int sum_mvr;
  // Sum of motion vector column.
  int sum_mvc;
  // Sum of absolute value of motion vector row.
  int sum_mvr_abs;
  // Sum of absolute value of motion vector column.
  int sum_mvc_abs;
  // Sum of the square of motion vector row.
  int64_t sum_mvrs;
  // Sum of the square of motion vector column.
  int64_t sum_mvcs;
  // A factor calculated using intra pred error.
  double intra_factor;
  // A factor that measures brightness.
  double brightness_factor;
} FRAME_STATS;
 
// This structure contains first pass data.
typedef struct {
  // Buffer holding frame stats for all MACROBLOCKs.
  // mb_stats[i] stores the FRAME_STATS of the ith
  // MB in raster scan order.
  FRAME_STATS *mb_stats;
  // Buffer to store the prediction error of the (0,0) motion
  // vector using the last source frame as the reference.
  // raw_motion_err_list[i] stores the raw_motion_err of
  // the ith MB in raster scan order.
  int *raw_motion_err_list;
} FirstPassData;
 
struct AV1_COMP;
struct EncodeFrameParams;
struct AV1EncoderConfig;
struct TileDataEnc;
 
static inline int is_fp_wavelet_energy_invalid(
    const FIRSTPASS_STATS *fp_stats) {
  assert(fp_stats != NULL);
  return (fp_stats->frame_avg_wavelet_energy < 0);
}
 
static inline BLOCK_SIZE get_fp_block_size(int is_screen_content_type) {
  return (is_screen_content_type ? BLOCK_8X8 : BLOCK_16X16);
}
 
int av1_get_unit_rows_in_tile(const TileInfo *tile,
                              const BLOCK_SIZE fp_block_size);
int av1_get_unit_cols_in_tile(const TileInfo *tile,
                              const BLOCK_SIZE fp_block_size);
 
void av1_first_pass_row(struct AV1_COMP *cpi, struct ThreadData *td,
                        struct TileDataEnc *tile_data, const int mb_row,
                        const BLOCK_SIZE fp_block_size);
void av1_end_first_pass(struct AV1_COMP *cpi);
 
void av1_free_firstpass_data(FirstPassData *firstpass_data);
 
void av1_twopass_zero_stats(FIRSTPASS_STATS *section);
void av1_accumulate_stats(FIRSTPASS_STATS *section,
                          const FIRSTPASS_STATS *frame);

void av1_first_pass(struct AV1_COMP *cpi, const int64_t ts_duration);
 
void av1_noop_first_pass_frame(struct AV1_COMP *cpi, const int64_t ts_duration);
#ifdef __cplusplus
}  // extern "C"
#endif
 
#endif  // AOM_AV1_ENCODER_FIRSTPASS_H_